
#include "test_list.h"

#ifdef TEST_STL_COMPATIBLE

#include <den/meta/is_stl_compatible.h>

#include <map>
#include <list>
#include <vector>
#include <string>

#if defined(__GNUC__) || defined(__MINGW__) || defined(__MINGW32__)
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wconversion-null"
#endif

#define TEST_CASE_NAME Den
#define TEST_NUMBER(n) is_stl_compatible##_##n


#define TEST_STL_COMPATIBLE_000
#define TEST_STL_COMPATIBLE_001
#define TEST_STL_COMPATIBLE_002
#define TEST_STL_COMPATIBLE_003
#define TEST_STL_COMPATIBLE_004
#define TEST_STL_COMPATIBLE_005
#define TEST_STL_COMPATIBLE_006
#define TEST_STL_COMPATIBLE_007
#define TEST_STL_COMPATIBLE_008
#define TEST_STL_COMPATIBLE_009
#define TEST_STL_COMPATIBLE_010
#define TEST_STL_COMPATIBLE_011
#define TEST_STL_COMPATIBLE_012
#define TEST_STL_COMPATIBLE_013
#define TEST_STL_COMPATIBLE_014
#define TEST_STL_COMPATIBLE_015
#define TEST_STL_COMPATIBLE_016
#define TEST_STL_COMPATIBLE_017
#define TEST_STL_COMPATIBLE_018
#define TEST_STL_COMPATIBLE_019
#define TEST_STL_COMPATIBLE_020
#define TEST_STL_COMPATIBLE_021
#define TEST_STL_COMPATIBLE_022
#define TEST_STL_COMPATIBLE_023
#define TEST_STL_COMPATIBLE_024
#define TEST_STL_COMPATIBLE_025
#define TEST_STL_COMPATIBLE_026
#define TEST_STL_COMPATIBLE_027
#define TEST_STL_COMPATIBLE_028
#define TEST_STL_COMPATIBLE_029
#define TEST_STL_COMPATIBLE_030
#define TEST_STL_COMPATIBLE_031
#define TEST_STL_COMPATIBLE_032

//------------------------------------------------------------------------------------------------------//

namespace{


    
}//namespace

//------------------------------------------------------------------------------------------------------//

#ifdef TEST_STL_COMPATIBLE_000
TEST(TEST_CASE_NAME, TEST_NUMBER(000))
{
}
#endif // TEST_STL_COMPATIBLE_000

#ifdef TEST_STL_COMPATIBLE_001
TEST(TEST_CASE_NAME, TEST_NUMBER(001))
{
    const bool success1
            = has_begin< int >::value;
    EXPECT_EQ(false, success1 );

    const bool success2
            = has_begin< ::std::vector<int> >::value;
    EXPECT_EQ(true, success2 );

    const bool success3
            = has_begin< ::std::map<int,int> >::value;
    EXPECT_EQ(true, success3 );

    const bool success4
            = has_begin< ::std::list<int> >::value;
    EXPECT_EQ(true, success4 );
}
#endif // TEST_STL_COMPATIBLE_001

#ifdef TEST_STL_COMPATIBLE_002
TEST(TEST_CASE_NAME, TEST_NUMBER(002))
{
    const bool success1
            = has_end< int >::value;
    EXPECT_EQ(false, success1 );

    const bool success2
            = has_end< ::std::vector<int> >::value;
    EXPECT_EQ(true, success2 );

    const bool success3
            = has_end< ::std::map<int,int> >::value;
    EXPECT_EQ(true, success3 );

    const bool success4
            = has_end< ::std::list<int> >::value;
    EXPECT_EQ(true, success4 );
}
#endif // TEST_STL_COMPATIBLE_002

#ifdef TEST_STL_COMPATIBLE_003
TEST(TEST_CASE_NAME, TEST_NUMBER(003))
{
    const bool success1
            = has_value_type< int >::value;
    EXPECT_EQ(false, success1 );

    const bool success2
            = has_value_type< ::std::vector<int> >::value;
    EXPECT_EQ(true, success2 );

    const bool success3
            = has_value_type< ::std::map<int,int> >::value;
    EXPECT_EQ(true, success3 );

    const bool success4
            = has_value_type< ::std::list<int> >::value;
    EXPECT_EQ(true, success4 );
}
#endif // TEST_STL_COMPATIBLE_003

#ifdef TEST_STL_COMPATIBLE_004
TEST(TEST_CASE_NAME, TEST_NUMBER(004))
{
    const bool success1
            = has_mapped_type< int >::value;
    EXPECT_EQ(false, success1 );

    const bool success2
            = has_mapped_type< ::std::vector<int> >::value;
    EXPECT_EQ(false, success2 );

    const bool success3
            = has_mapped_type< ::std::map<int,int> >::value;
    EXPECT_EQ(true, success3 );

    const bool success4
            = has_mapped_type< ::std::list<int> >::value;
    EXPECT_EQ(false, success4 );
}
#endif // TEST_STL_COMPATIBLE_004

#ifdef TEST_STL_COMPATIBLE_005
TEST(TEST_CASE_NAME, TEST_NUMBER(005))
{
    const bool success1
            = has_iterator< int >::value;
    EXPECT_EQ(false, success1 );

    const bool success2
            = has_iterator< ::std::vector<int> >::value;
    EXPECT_EQ(true, success2 );

    const bool success3
            = has_iterator< ::std::map<int,int> >::value;
    EXPECT_EQ(true, success3 );

    const bool success4
            = has_iterator< ::std::list<int> >::value;
    EXPECT_EQ(true, success4 );
}
#endif // TEST_STL_COMPATIBLE_005

#ifdef TEST_STL_COMPATIBLE_006
TEST(TEST_CASE_NAME, TEST_NUMBER(006))
{
    const bool success1 =
            has_const_iterator< int >::value;
    EXPECT_EQ(false, success1 );

    const bool success2 =
            has_const_iterator< ::std::vector<int> >::value;
    EXPECT_EQ(true, success2 );

    const bool success3 =
            has_const_iterator< ::std::map<int,int> >::value;
    EXPECT_EQ(true, success3 );

    const bool success4 =
            has_const_iterator< ::std::list<int> >::value;
    EXPECT_EQ(true, success4 );
}
#endif // TEST_STL_COMPATIBLE_006

#ifdef TEST_STL_COMPATIBLE_007
TEST(TEST_CASE_NAME, TEST_NUMBER(007))
{
    const bool success1 =
            is_stl_compatible< int >::value;
    EXPECT_EQ(false, success1 );

    const bool success2 =
            is_stl_compatible< ::std::vector<int> >::value;
    EXPECT_EQ(true, success2 );

    const bool success3 =
            is_stl_compatible< ::std::map<int,int> >::value;
    EXPECT_EQ(true, success3 );

    const bool success4 =
            is_stl_compatible< ::std::list<int> >::value;
    EXPECT_EQ(true, success4 );
}
#endif // TEST_STL_COMPATIBLE_007

#ifdef TEST_STL_COMPATIBLE_008
TEST(TEST_CASE_NAME, TEST_NUMBER(008))
{
    const bool success1 =
            is_stl_compatible< int >::eIS_ASSOCIATIVE;
    EXPECT_EQ(false, success1 );

    const bool success2 =
            is_stl_compatible< ::std::vector<int> >::eIS_ASSOCIATIVE;
    EXPECT_EQ(false, success2 );

    const bool success3 =
            is_stl_compatible< ::std::map<int,int> >::eIS_ASSOCIATIVE;
    EXPECT_EQ(true, success3 );

    const bool success4 =
            is_stl_compatible< ::std::list<int> >::eIS_ASSOCIATIVE;
    EXPECT_EQ(false, success4 );
}
#endif // TEST_STL_COMPATIBLE_008

#ifdef TEST_STL_COMPATIBLE_009
TEST(TEST_CASE_NAME, TEST_NUMBER(009))
{
    const bool success1 =
            is_stl_compatible< int >::eIS_LENEAR;
    EXPECT_EQ(false, success1 );

    const bool success2 =
            is_stl_compatible< ::std::vector<int> >::eIS_LENEAR;
    EXPECT_EQ(true, success2 );

    const bool success3 =
            is_stl_compatible< ::std::map<int,int> >::eIS_LENEAR;
    EXPECT_EQ(false, success3 );

    const bool success4 =
            is_stl_compatible< ::std::list<int> >::eIS_LENEAR;
    EXPECT_EQ(true, success4 );
}
#endif // TEST_STL_COMPATIBLE_009

#ifdef TEST_STL_COMPATIBLE_010
#endif // TEST_STL_COMPATIBLE_010

#ifdef TEST_STL_COMPATIBLE_011
#endif // TEST_STL_COMPATIBLE_011

#ifdef TEST_STL_COMPATIBLE_012
#endif // TEST_STL_COMPATIBLE_012

#ifdef TEST_STL_COMPATIBLE_013
#endif // TEST_STL_COMPATIBLE_013

#ifdef TEST_STL_COMPATIBLE_014
#endif // TEST_STL_COMPATIBLE_014

#ifdef TEST_STL_COMPATIBLE_015
#endif // TEST_STL_COMPATIBLE_015

#ifdef TEST_STL_COMPATIBLE_016
#endif // TEST_STL_COMPATIBLE_016

#ifdef TEST_STL_COMPATIBLE_017
#endif // TEST_STL_COMPATIBLE_017

#ifdef TEST_STL_COMPATIBLE_018
#endif // TEST_STL_COMPATIBLE_018

#ifdef TEST_STL_COMPATIBLE_019
#endif // TEST_STL_COMPATIBLE_019

#ifdef TEST_STL_COMPATIBLE_020
#endif // TEST_STL_COMPATIBLE_020

#ifdef TEST_STL_COMPATIBLE_021
#endif // TEST_STL_COMPATIBLE_021

#ifdef TEST_STL_COMPATIBLE_022
#endif // TEST_STL_COMPATIBLE_022

#ifdef TEST_STL_COMPATIBLE_023
#endif // TEST_STL_COMPATIBLE_023

#ifdef TEST_STL_COMPATIBLE_024
#endif // TEST_STL_COMPATIBLE_024

#ifdef TEST_STL_COMPATIBLE_025
#endif // TEST_STL_COMPATIBLE_025

#ifdef TEST_STL_COMPATIBLE_026
#endif // TEST_STL_COMPATIBLE_026

#ifdef TEST_STL_COMPATIBLE_027
#endif // TEST_STL_COMPATIBLE_027

#ifdef TEST_STL_COMPATIBLE_028
#endif // TEST_STL_COMPATIBLE_028

#ifdef TEST_STL_COMPATIBLE_029
#endif // TEST_STL_COMPATIBLE_029

#ifdef TEST_STL_COMPATIBLE_030
#endif // TEST_STL_COMPATIBLE_030

#ifdef TEST_STL_COMPATIBLE_031
#endif // TEST_STL_COMPATIBLE_031

#ifdef TEST_STL_COMPATIBLE_032
#endif // TEST_STL_COMPATIBLE_032


#if defined(__GNUC__) || defined(__MINGW__) || defined(__MINGW32__)
    #pragma GCC diagnostic pop
#endif



#endif //TEST_STL_COMPATIBLE



